#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygtk
pygtk.require('2.0')
import gtk
import time
import sqlite3
import string
import urllib2
import sys
import os
import re
sys.path.append("images")
import gtkxpm

class DrawGUI:
	TARGET_TYPE_TEXT = 80
	TARGET_TYPE_PIXMAP = 81
	fromImage = [ ( "text/plain", 0, TARGET_TYPE_TEXT ), ( "image/x-xpixmap", 0, TARGET_TYPE_PIXMAP ) ]
	toButton = [ ( "text/plain", 0, TARGET_TYPE_TEXT ) ]
	toCanvas = [ ( "image/x-xpixmap", 0, TARGET_TYPE_PIXMAP ) ]

	def layout_resize(self, widget, event):
		x, y, width, height = widget.get_allocation()
		if width > self.lwidth or height > self.lheight:
			self.lwidth = max(width, self.lwidth)
			self.lheight = max(height, self.lheight)
			widget.set_size(self.lwidth, self.lheight)

	def changed_cb_filter_report(self, entry):
		self.filter_report = entry.get_text()

	def reportgen_changed_cb(self, combobox, treeview, liststore):
		gtk.ListStore.clear(liststore)
		model = combobox.get_model()
		index = combobox.get_active()
		if index >= 0:
			self.relatorio = model[index][0]

		model = treeview.get_model()
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()

		if "pneus em uso" == self.relatorio:
			query = "SELECT id_pneu, placa, data_registro FROM pneu WHERE placa IS NOT NULL and status != -1"
			msg = "pneu"
		elif "pneus fora de uso" in self.relatorio:
			query = "SELECT id_pneu, placa, data_registro FROM pneu WHERE placa IS NULL AND status != -1"
			msg = "pneu"
		elif "todos pneus" == self.relatorio:
			query = "SELECT id_pneu, placa, data_registro FROM pneu WHERE status != -1"
			msg = "pneu"
		elif "veículos sem estepe" == self.relatorio:
			query = "SELECT placa, num_eixos, data_registro FROM veiculo WHERE placa NOT IN (SELECT placa FROM pneu WHERE posicao_eixo LIKE 'estepe%')"
			msg = "veiculo"
		elif "cadastro de usuários" == self.relatorio:
			query = "SELECT login, data_registro, registro FROM log WHERE registro LIKE 'sucesso ao cadastrar usuário%'"
			msg = "log"
		elif "descadastro de usuários" == self.relatorio:
			query = "SELECT login, data_registro, registro FROM log WHERE registro LIKE 'sucesso ao descadastrar usuário%'"
			msg = "log"
		elif "cadastro de pneus" == self.relatorio:
			query = "SELECT login, data_registro, registro FROM log WHERE registro LIKE 'sucesso ao cadastrar pneu%'"
			msg = "log"
		elif "descadastro de pneus" == self.relatorio:
			query = "SELECT login, data_registro, registro FROM log WHERE registro LIKE 'sucesso ao descadastrar pneu%'"
			msg = "log"
		elif "cadastro de veículos" == self.relatorio:
			query = "SELECT login, data_registro, registro FROM log WHERE registro LIKE 'sucesso ao cadastrar veículo%'"
			msg = "log"
		elif "descadastro de veículos" == self.relatorio:
			query = "SELECT login, data_registro, registro FROM log WHERE registro LIKE 'sucesso ao descadastrar veículo%'"
			msg = "log"
		elif "registro de acessos" == self.relatorio:
			query = "SELECT login, data_registro, registro FROM log WHERE registro LIKE 'sucesso ao logar%'"
			msg = "log"
		elif "##" in self.relatorio:
			self.report_stbar.push(0, "0 resultados encontrados")
			return

		if self.rep == 'semanal':
			query = query + " AND data_registro >= DATETIME('now', '-7 days')"
		elif self.rep == 'mensal':
			query = query + " AND data_registro >= DATETIME('now', 'start of month')"
		elif self.rep == 'anual':
			query = query + " AND data_registro >= DATETIME('now', 'start of year')"

		if "stro" in self.relatorio:
			if len(self.filter_report) > 0:
				query = query + " AND login LIKE '%%%s%%';" % (self.filter_report)
		else:
			add = query + ";"

		cursor.execute(query)
		results = cursor.fetchall()

		self.report_pdf = []
		counter = 1
		for entry in results:
			if msg == "pneu":
				if entry[1] == None:
					a = "Pneu: " + entry[0] + " | " + "Veiculo: Vazio | " + "Data de registro: " + entry[2]
				else:
					a = "Pneu: " + entry[0] + " | " + "Veiculo: " + entry[1] + " | " + "Data de registro: " + entry[2]
			elif msg == "veiculo":
					a = "Veiculo: " + entry[0] + " | " + "Eixos: " + str(entry[1]) + " | " + "Data de registro: " + entry[2]
			else:
					a = "Login: " + entry[0] + " | " + "Registro: " + entry[2] + " | " + "Data de registro: " + entry[1]
			model.append([a])
			self.report_pdf.append(a)
			counter += 1

		msg = "%d resultados encontrados" % (counter-1)
		self.report_stbar.push(0, msg)

	def report_interval(self, foo=None, freq=None):
		self.rep = freq.get_label()
		return

	def relatorio(self, foo=None, bar=None):
		if self.login_session is not None:
			window = gtk.Window(gtk.WINDOW_TOPLEVEL)
			window.set_title("Relatórios")
			window.set_size_request(710, 300)
			window.connect("destroy", lambda w: window.destroy())

			scrolledwindow = gtk.ScrolledWindow()
			vbox = gtk.VBox()

			hbox = gtk.HBox()
			vbox.pack_start(hbox, expand=False, fill=False, padding=0)
			user_report_label = gtk.Label("Natureza do relatório:")
			hbox.pack_start(user_report_label, expand=False, fill=False, padding=5)
			combobox = gtk.combo_box_new_text()
			combobox.set_active(0)
			combobox.append_text(str("## Estoque ##"))
			combobox.append_text(str("pneus em uso"))
			combobox.append_text(str("pneus fora de uso"))
			combobox.append_text(str("todos pneus"))
			combobox.append_text(str("## Mecânica ##"))
			combobox.append_text(str("veículos sem estepe"))
			combobox.append_text(str("## Auditoria ##"))
			combobox.append_text(str("cadastro de usuários"))
			combobox.append_text(str("descadastro de usuários"))
			combobox.append_text(str("cadastro de pneus"))
			combobox.append_text(str("descadastro de pneus"))
			combobox.append_text(str("cadastro de veículos"))
			combobox.append_text(str("descadastro de veículos"))
			combobox.append_text(str("registro de acessos"))
			hbox.pack_start(combobox, expand=False, fill=False, padding=0)

			user_filter_hbox = gtk.HBox(True, 0)
			hbox.add(user_filter_hbox)
			user_filter_label = gtk.Label("Filtro por usuário:")
			user_filter_hbox.pack_start(user_filter_label, expand=False, fill=False, padding=5)
			user_filter_cbentry = gtk.combo_box_entry_new_text()
			user_filter_hbox.pack_start(user_filter_cbentry, expand=False, fill=False, padding=0)
			user_filter_cbentry.child.connect('changed', self.changed_cb_filter_report)

			user_filter_cbentry.set_active(0)
			user_filter_cbentry.append_text('')

			self.rep = ''
			self.filter_report = ''

			# Carregar lista de usuarios cadastrados
			database = sqlite3.connect('database/db.sqlite')
			cursor = database.cursor()
			cursor.execute("SELECT login FROM usuario WHERE status != -1 ORDER BY login;")
			results = cursor.fetchall()

			for entry in results:
				user_filter_cbentry.append_text(str(entry[0]))

			database.close()

			check_hbox = gtk.HBox(True, 0)
			vbox.pack_start(check_hbox, expand=False, fill=False, padding=0)
			semanal = gtk.CheckButton("semanal")
			semanal.connect("toggled", self.report_interval, semanal)
			check_hbox.pack_start(semanal, expand=False, fill=False, padding=0)

			mensal = gtk.CheckButton("mensal")
			mensal.connect("toggled", self.report_interval, mensal)
			check_hbox.pack_start(mensal, expand=False, fill=False, padding=0)

			anual = gtk.CheckButton("anual")
			anual.connect("toggled", self.report_interval, anual)
			check_hbox.pack_start(anual, expand=False, fill=False, padding=0)
 
			hbox = gtk.HButtonBox()
			vbox.pack_start(scrolledwindow, True)
			vbox.pack_start(hbox, False)
			b0 = gtk.Button('Limpar')
			b1 = gtk.Button('Sair')
			b1.connect("clicked", self.destroy, window)
			b2 = gtk.Button('Imprimir')
			hbox.pack_start(b0)
			hbox.pack_start(b1)
			hbox.pack_start(b2)
			liststore = gtk.ListStore(str)
			treeview = gtk.TreeView(liststore)
			combobox.connect('changed', self.reportgen_changed_cb, treeview, liststore)
			cell = gtk.CellRendererText()
			tvcolumn = gtk.TreeViewColumn('Registro', cell, text=0)
			treeview.append_column(tvcolumn)
			treeview.set_search_column(0)
			tvcolumn.set_sort_column_id(0)

			b0.connect_object('clicked', gtk.ListStore.clear, liststore)
			b2.connect("clicked", self.imprimir)

			self.report_stbar = gtk.Statusbar()
			vbox.pack_end(self.report_stbar, expand=False, fill=True, padding=0)
			self.report_stbar.push(0, "Nenhum relatório selecionado")

			scrolledwindow.add(treeview)
			window.add(vbox)
			window.show_all()
		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Sessão inválida!", "Você deve logar para executar esta operação!")
		return

	def mechanic_changed_cb(self, combobox):
		model = combobox.get_model()
		index = combobox.get_active()
		if index >= 0:
			self.pneu = model[index][0]

	def makeLayout(self):
		self.pneu = -1
		self.lwidth = 600
		self.lheight = 600

		vbox = gtk.VBox(False, 0)
		self.window.add(vbox)
		self.notebook = gtk.Notebook()
		self.notebook.set_tab_pos(gtk.POS_TOP)
		vbox.pack_start(self.notebook, expand=True, fill=True, padding=0)
		self.notebook.show()
		self.show_tabs = True
		self.show_border = True

		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()
		
		cursor.execute("SELECT placa, num_eixos, eixos_duplos FROM veiculo WHERE status != -1;")
		results = cursor.fetchall()

		self.dict = { }
		msg = ''
		for entry in results:
			self.frame = gtk.Frame()
			self.frame.set_border_width(10)
			self.frame.set_size_request(100, 75)

			ntb_vbox = gtk.VBox(False, 0)
			self.frame.add(ntb_vbox)

			label = gtk.Label(entry[0])
			self.notebook.append_page(self.frame, label)

			self.layout = gtk.Layout()
			ntb_vbox.pack_start(self.layout, True, True, 0)
			self.layout.set_size(300, 500)
			self.layout.drag_dest_set(gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_HIGHLIGHT | gtk.DEST_DEFAULT_DROP, self.toCanvas, gtk.gdk.ACTION_COPY)

			combobox = gtk.combo_box_new_text()
			combobox.connect('changed', self.mechanic_changed_cb)
			combobox.set_active(0)
			self.layout.put(combobox, 295, 105)
			databasep = sqlite3.connect('database/db.sqlite')
			cursor = databasep.cursor()
			query = "SELECT id_pneu FROM pneu WHERE status != -1 ORDER BY id_pneu;"
			cursor.execute(query)
			results = cursor.fetchall()

			combobox.append_text(str("nulo"))

			for pneu in results:
				combobox.append_text(str(pneu[0]))

			databasep.close()

			im = gtk.Image()
			pixbuf = gtk.gdk.pixbuf_new_from_file("images/tire_button.png")
			scaled_buf = pixbuf.scale_simple(51,51,gtk.gdk.INTERP_BILINEAR)
			im.set_from_pixbuf(scaled_buf)
			im.show()
			button = gtk.Button()
			button.add(im)
			button.connect("drag_data_get", self.sendCallback)
			button.drag_source_set(gtk.gdk.BUTTON1_MASK, self.fromImage, gtk.gdk.ACTION_COPY)
			button.show_all()
			self.layout.put(button, 295, 140)

			# Estepe 1
			estepe1 = gtk.Label("Estepe 1")
			estepe1.show()
			self.layout.put(estepe1, 260, 0)

			im = gtk.Image()
			pixbuf = gtk.gdk.pixbuf_new_from_file("images/label.jpg")
			scaled_buf = pixbuf.scale_simple(51,20,gtk.gdk.INTERP_BILINEAR)
			im.set_from_pixbuf(scaled_buf)
			im.show()
			self.layout.put(im, 260, 15)

			im = gtk.Image()
			estepe = database.cursor()		
			estepe.execute("SELECT id_pneu FROM pneu WHERE placa = '%s' and posicao_eixo = 'estepe1';" % (gtk.Label.get_text(label)))
			estepe_r = estepe.fetchone()
			if estepe_r is None:
				pixbuf = gtk.gdk.pixbuf_new_from_file("images/estepe-null.png")
				pneu_estepe1 = gtk.Label("")
			else:
				pixbuf = gtk.gdk.pixbuf_new_from_file("images/estepe-full.png")
				pneu_estepe1 = gtk.Label(estepe_r[0])

			pneu_estepe1.show()
			self.layout.put(pneu_estepe1, 260, 15)

			scaled_buf = pixbuf.scale_simple(51,51,gtk.gdk.INTERP_BILINEAR)
			im.set_from_pixbuf(scaled_buf)
			im.show()
			self.layout.put(im, 260, 30)

			# Estepe 2
			estepe2 = gtk.Label("Estepe 2")
			estepe2.show()
			self.layout.put(estepe2, 330, 0)

			im = gtk.Image()
			pixbuf = gtk.gdk.pixbuf_new_from_file("images/label.jpg")
			scaled_buf = pixbuf.scale_simple(51,20,gtk.gdk.INTERP_BILINEAR)
			im.set_from_pixbuf(scaled_buf)
			im.show()
			self.layout.put(im, 330, 15)

			im = gtk.Image()
			estepe.execute("SELECT id_pneu, posicao_eixo FROM pneu WHERE placa = '%s' and posicao_eixo = 'estepe2';" % (gtk.Label.get_text(label)))
			estepe_r = estepe.fetchone()
			if estepe_r is None:
				pixbuf = gtk.gdk.pixbuf_new_from_file("images/estepe-null.png")
				pneu_estepe2 = gtk.Label("")
			else:
				pixbuf = gtk.gdk.pixbuf_new_from_file("images/estepe-full.png")
				pneu_estepe2 = gtk.Label(estepe_r[0])

			pneu_estepe2.show()
			self.layout.put(pneu_estepe2, 330, 15)

			scaled_buf = pixbuf.scale_simple(51,51,gtk.gdk.INTERP_BILINEAR)
			im.set_from_pixbuf(scaled_buf)
			im.show()
			self.layout.put(im, 330, 30)

			hpneu = 20
			heixo = 0
			for counter in range (entry[1]):

				if counter == 0:
					im = gtk.Image()
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/eixo-dianteiro.png")
					scaled_buf = pixbuf.scale_simple(250,100,gtk.gdk.INTERP_BILINEAR)
					im.set_from_pixbuf(scaled_buf)
					im.show()
					self.layout.put(im, 0, heixo)

				elif ((counter > 0) and (counter < entry[1]-1)):
					im = gtk.Image()
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/eixo-meio.png")
					scaled_buf = pixbuf.scale_simple(250,100,gtk.gdk.INTERP_BILINEAR)
					im.set_from_pixbuf(scaled_buf)
					im.show()
					self.layout.put(im, 0, heixo)

					if (entry[2] == 1):
						if ((counter != 1) or (entry[1] != 4)):
							msg = "e" + str(counter) + "1"
							cursor = database.cursor()
							cursor.execute("SELECT id_pneu, posicao_eixo FROM pneu WHERE posicao_eixo = '%s' and placa = '%s';" % (msg, gtk.Label.get_text(label)))
							idp = cursor.fetchone()
							imp = gtk.Image()

							if idp is None:
								pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-vazio.jpg")
								self.dict = { msg : gtk.Label() }
							else:
								pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-cheio.jpg")
								self.dict = { msg : gtk.Label(idp[0]) }

							scaled_buf = pixbuf.scale_simple(30,60,gtk.gdk.INTERP_BILINEAR)
							imp.set_from_pixbuf(scaled_buf)
							imp.show()
							self.layout.put(imp, 60, hpneu)
							self.layout.put(self.dict[msg], 50, hpneu-15)

							msg = "d" + str(counter) + "1"
							cursor = database.cursor()
							cursor.execute("SELECT id_pneu, posicao_eixo FROM pneu WHERE posicao_eixo = '%s' and placa = '%s';" % (msg, gtk.Label.get_text(label)))
							idp = cursor.fetchone()
							imp = gtk.Image()

							if idp is None:
								pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-vazio.jpg")
								self.dict = { msg : gtk.Label() }
							else:
								pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-cheio.jpg")
								self.dict = { msg : gtk.Label(idp[0]) }

							scaled_buf = pixbuf.scale_simple(30,60,gtk.gdk.INTERP_BILINEAR)
							imp.set_from_pixbuf(scaled_buf)
							imp.show()
							self.layout.put(imp, 160, hpneu)
							self.layout.put(self.dict[msg], 150, hpneu-15)
				else:
					im = gtk.Image()
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/eixo-traseiro.png")
					scaled_buf = pixbuf.scale_simple(250,100,gtk.gdk.INTERP_BILINEAR)
					im.set_from_pixbuf(scaled_buf)
					im.show()
					self.layout.put(im, 0, heixo)

					if entry[2] == 1:
						msg = "e" + str(counter) + "1"
						cursor = database.cursor()
						cursor.execute("SELECT id_pneu, posicao_eixo FROM pneu WHERE posicao_eixo = '%s' and placa = '%s';" % (msg, gtk.Label.get_text(label)))
						idp = cursor.fetchone()
						imp = gtk.Image()

						if idp is None:
							pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-vazio.jpg")
							self.dict = { msg : gtk.Label() }
						else:
							pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-cheio.jpg")
							self.dict = { msg : gtk.Label(idp[0]) }

						scaled_buf = pixbuf.scale_simple(30,60,gtk.gdk.INTERP_BILINEAR)
						imp.set_from_pixbuf(scaled_buf)
						imp.show()
						self.layout.put(imp, 60, hpneu)
						self.layout.put(self.dict[msg], 50, hpneu-15)

						msg = "d" + str(counter) + "1"
						cursor = database.cursor()
						cursor.execute("SELECT id_pneu, posicao_eixo FROM pneu WHERE posicao_eixo = '%s' and placa = '%s';" % (msg, gtk.Label.get_text(label)))
						idp = cursor.fetchone()
						imp = gtk.Image()

						if idp is None:
							pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-vazio.jpg")
							self.dict = { msg : gtk.Label() }
						else:
							pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-cheio.jpg")
							self.dict = { msg : gtk.Label(idp[0]) }

						scaled_buf = pixbuf.scale_simple(30,60,gtk.gdk.INTERP_BILINEAR)
						imp.set_from_pixbuf(scaled_buf)
						imp.show()
						self.layout.put(imp, 160, hpneu)
						self.layout.put(self.dict[msg], 150, hpneu-15)

				msg = "e" + str(counter) + "0"
				cursor = database.cursor()
				cursor.execute("SELECT id_pneu, posicao_eixo FROM pneu WHERE posicao_eixo = '%s' and placa = '%s';" % (msg, gtk.Label.get_text(label)))
				idp = cursor.fetchone()
				imp = gtk.Image()

				if idp is None:
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-vazio.jpg")
					self.dict = { msg : gtk.Label() }
				else:
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-cheio.jpg")
					self.dict = { msg : gtk.Label(idp[0]) }

				scaled_buf = pixbuf.scale_simple(30,60,gtk.gdk.INTERP_BILINEAR)
				imp.set_from_pixbuf(scaled_buf)
				imp.show()
				self.layout.put(imp, 10, hpneu)
				self.layout.put(self.dict[msg], 0, hpneu-15)


				msg = "d" + str(counter) + "0"
				cursor = database.cursor()
				cursor.execute("SELECT id_pneu, posicao_eixo FROM pneu WHERE posicao_eixo = '%s' and placa = '%s';" % (msg, gtk.Label.get_text(label)))
				idp = cursor.fetchone()
				imp = gtk.Image()

				if idp is None:
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-vazio.jpg")
					self.dict = { msg : gtk.Label() }
				else:
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-cheio.jpg")
					self.dict = { msg : gtk.Label(idp[0]) }

				scaled_buf = pixbuf.scale_simple(30,60,gtk.gdk.INTERP_BILINEAR)
				imp.set_from_pixbuf(scaled_buf)
				imp.show()
				self.layout.put(imp, 210, hpneu)
				self.layout.put(self.dict[msg], 200, hpneu-15)

				hpneu += 90
				heixo += 100

			self.layout.connect("drag_data_received", self.receiveCallback, self.layout, gtk.Label.get_text(self.notebook.get_tab_label(self.frame)))

			button_box = gtk.HButtonBox()
			ntb_vbox.pack_start(button_box, expand=False, fill=False, padding=0)
			button_cancelar = gtk.Button("Sair")
			button_box.add(button_cancelar)
			button_cancelar.connect("clicked", self.destroy, self.window)

		self.window.show_all()
		database.close()
		return

	def addImage(self, xpm, xd, yd):
		style = self.window.get_style()
		pixmap, mask = gtk.gdk.pixmap_create_from_xpm_d(self.window.window, style.bg[gtk.STATE_NORMAL], xpm)
		image = gtk.Image()
		image.set_from_pixmap(pixmap, mask)
		button = gtk.Button()
		button.add(image)
		button.connect("drag_data_get", self.sendCallback)
		button.drag_source_set(gtk.gdk.BUTTON1_MASK, self.fromImage, gtk.gdk.ACTION_COPY)
		button.show_all()
		return

	def sendCallback(self, widget, context, selection, targetType, eventTime):
		if targetType == self.TARGET_TYPE_TEXT:
			now = time.time()
			str = time.ctime(now)
			selection.set(selection.target, 8, str)
		elif targetType == self.TARGET_TYPE_PIXMAP:
			selection.set(selection.target, 8,
			string.join(gtkxpm.gtk_xpm, '\n'))

	def receiveCallback(self, widget, context, x, y, selection, targetType, time, lay, veiculo):
		newx = newy = 0

		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()

		cursor.execute("SELECT num_eixos, eixos_duplos FROM veiculo WHERE placa = '%s'" % (veiculo))
		veiculo_num_eixos = cursor.fetchone()

		if self.pneu == -1:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Operação inválida!", "Você deve selecionar um pneu para esta operação!")
			return

		if targetType == self.TARGET_TYPE_TEXT:
			label = widget.get_children()[0]
			label.set_text(selection.data)
		elif targetType == self.TARGET_TYPE_PIXMAP:
			self.addImage(string.split(selection.data, '\n'), x, y)

		imp = gtk.Image()
		if self.pneu == "nulo":
			pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-vazio.jpg")
		else:
			pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-cheio.jpg")
			cursor.execute("SELECT placa FROM pneu WHERE id_pneu = '%s'" % (self.pneu))
			result = cursor.fetchone()
			if result[0] is not None:
				msg = "Este pneu já está associado ao veículo %s" % result[0]
				self.custom_dlg(gtk.MESSAGE_ERROR, "Operação inválida!", msg)
				database.close()
				return

		scaled_buf = pixbuf.scale_simple(30,60,gtk.gdk.INTERP_BILINEAR)
		imp.set_from_pixbuf(scaled_buf)
		imp.show()
		pos = '' 

		if x >= 5 and x <= 45:	
			# print "esquerda 0"
			if y >= 15 and y <= 95:
				pos = "e00"
				newx = 10
				newy = 20

			elif y >= 105 and y <= 185:
				pos = "e10"
				newx = 10
				newy = 110

			elif y >= 195 and y <= 275:
				if veiculo_num_eixos[0] >= 3:
					pos = "e20"
					newx = 10
					newy = 200
				else:
					return
			elif y >= 285 and y <= 365:
				if veiculo_num_eixos[0] >= 4:
					pos = "e30"
					newx = 10
					newy = 290
				else:
					return


		elif x >= 55 and x <= 95:
			if veiculo_num_eixos[1] == 1:
				# print "esquerda 1"
				if y >= 15 and y <= 95:
					#pos = "e01"
					#newx = 60
					#newy = 20
					return

				elif y >= 105 and y <= 185:
					if veiculo_num_eixos[0] != 4:
						pos = "e11"
						newx = 60
						newy = 110
					else:
						return

				elif y >= 195 and y <= 275:
					if veiculo_num_eixos[0] >= 3:
						pos = "e21"
						newx = 60
						newy = 200
					else:
						return
				elif y >= 285 and y <= 365:
					if veiculo_num_eixos[0] >= 4:
						pos = "e31"
						newx = 60
						newy = 290
					else:
						return
			else:
				return

		elif x >= 155 and x <= 195:
			if veiculo_num_eixos[1] == 1:
				# print "direita 1"
				if y >= 15 and y <= 95:
					#pos = "d01"
					#newx = 160
					#newy = 20
					return

				elif y >= 105 and y <= 185:
					if veiculo_num_eixos[0] != 4:
						pos = "d11"
						newx = 160
						newy = 110
					else:
						return

				elif y >= 195 and y <= 275:
					if veiculo_num_eixos[0] >= 3:
						pos = "d21"
						newx = 160
						newy = 200
					else:
						return
				elif y >= 285 and y <= 365:
					if veiculo_num_eixos[0] >= 4:
						pos = "d31"
						newx = 160
						newy = 290
					else:
						return
			else:
				return

		elif x >= 215 and x <= 255:
			# print "direita 0"
			if y >= 15 and y <= 95:
				pos = "d00"
				newx = 210
				newy = 20

			elif y >= 105 and y <= 185:
				pos = "d10"
				newx = 210
				newy = 110

			elif y >= 195 and y <= 275:
				if veiculo_num_eixos[0] >= 3:
					pos = "d20"
					newx = 210
					newy = 200
				else:
					return
			elif y >= 285 and y <= 365:
				if veiculo_num_eixos[0] >= 4:
					pos = "d30"
					newx = 210
					newy = 290
				else:
					return

		elif x >= 255 and x <= 315:
			if y >= 25 and y <= 85:
				pos = "estepe1"

				if self.pneu == "nulo":
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/estepe-null.png")
				else:
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/estepe-full.png")

				scaled_buf = pixbuf.scale_simple(51,51,gtk.gdk.INTERP_BILINEAR)
				imp.set_from_pixbuf(scaled_buf)
				imp.show()

		elif x >= 325 and x <= 385:
			if y >= 25 and y <= 85:
				pos = "estepe2"

				if self.pneu == "nulo":
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/estepe-null.png")
				else:
					pixbuf = gtk.gdk.pixbuf_new_from_file("images/estepe-full.png")

				scaled_buf = pixbuf.scale_simple(51,51,gtk.gdk.INTERP_BILINEAR)
				imp.set_from_pixbuf(scaled_buf)
				imp.show()

		if len(pos) < 3:
			return

		if pos == "estepe1":
			im = gtk.Image()
			pixbuf = gtk.gdk.pixbuf_new_from_file("images/label.jpg")
			scaled_buf = pixbuf.scale_simple(51,20,gtk.gdk.INTERP_BILINEAR)
			im.set_from_pixbuf(scaled_buf)
			im.show()
			lay.put(im, 260, 15)

			lay.put(imp, 260, 30)
			ll = gtk.Label(self.pneu)
			ll.show()
			lay.put(ll, 260, 15)
		elif pos == "estepe2":
			im = gtk.Image()
			pixbuf = gtk.gdk.pixbuf_new_from_file("images/label.jpg")
			scaled_buf = pixbuf.scale_simple(51,20,gtk.gdk.INTERP_BILINEAR)
			im.set_from_pixbuf(scaled_buf)
			im.show()
			lay.put(im, 330, 15)

			lay.put(imp, 330, 30)
			ll = gtk.Label(self.pneu)
			ll.show()
			lay.put(ll, 330, 15)
		else:
			im = gtk.Image()
			pixbuf = gtk.gdk.pixbuf_new_from_file("images/label.jpg")
			scaled_buf = pixbuf.scale_simple(50,20,gtk.gdk.INTERP_BILINEAR)
			im.set_from_pixbuf(scaled_buf)
			im.show()
			lay.put(im, newx-10, newy-15)

			lay.put(imp, newx, newy)
			ll = gtk.Label(self.pneu)
			if self.pneu == "nulo":
				ll = gtk.Label()
			ll.show()
			lay.put(ll, newx-10, newy-15)

		cursor.execute("SELECT id_pneu FROM pneu WHERE posicao_eixo = '%s' AND placa = '%s';" % (pos, veiculo))
		atualiza_pneu = cursor.fetchone()
		if atualiza_pneu is not None:
			if self.pneu == "nulo":
				cursor.execute("UPDATE pneu set placa = NULL, posicao_eixo = NULL WHERE posicao_eixo = '%s' AND placa = '%s';" % (pos, veiculo))
				pixbuf = gtk.gdk.pixbuf_new_from_file("images/pneu-vazio.jpg")
			else:
				# atualiza antigo pneu
				cursor.execute("UPDATE pneu SET placa = NULL, posicao_eixo = NULL WHERE posicao_eixo = '%s' AND placa = '%s';" % (pos, veiculo))
				# atualiza novo pneu
				cursor.execute("UPDATE pneu SET placa = '%s', posicao_eixo = '%s' WHERE id_pneu = '%s';" % (veiculo, pos, self.pneu))
		else:
				cursor.execute("UPDATE pneu SET placa = '%s', posicao_eixo = '%s' WHERE id_pneu = '%s';" % (veiculo, pos, self.pneu))
		database.commit()
		database.close()
		return

	def destroy(self, foo=None, window=None):
		window.destroy()
		return

	def custom_dlg(self, tipo, titulo, mensagem):
		dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL, type=tipo, buttons=gtk.BUTTONS_OK)
		dialog.set_markup(titulo)
		dialog.format_secondary_markup(mensagem)
		dialog.run()
		dialog.destroy()
		return

	def usuario_add(self, foo=None, cb=None):
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()

		cursor.execute("SELECT status FROM usuario WHERE nome = '%s'" % (self.login_session))
		result = cursor.fetchone()
		if result[0] != 1:
			cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'falha ao cadastrar usuário %s');" % (self.login_session, self.usuario))
			# show a custom dialog
			self.custom_dlg(gtk.MESSAGE_ERROR, "Operação ilegal!", "Você precisa ser administrador para esta operação!")
			database.close()
			return

		if self.usuario:
			cursor.execute("SELECT nome FROM usuario WHERE nome = '%s'" % (self.usuario))
			result = cursor.fetchone()

			if result is None:
				# create user
				cursor.execute("INSERT INTO usuario (nome, login, senha, status, data_registro) VALUES ('%s', '%s', '%s', %d, strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'));" % (self.usuario, self.login_entry.get_text(), self.password_entry.get_text(), self.status))
				# register log in database
				cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'sucesso ao cadastrar usuário %s');" % (self.login_session, self.usuario))

				cb.append_text(self.usuario)

				# show a custom dialog
				msg = "Usuário %s cadastrado!" % (self.usuario)
				self.custom_dlg(gtk.MESSAGE_INFO, "Operação realizada!", msg)

			else:
				cursor.execute("SELECT status FROM usuario WHERE nome = '%s'" % (self.usuario))
				result = cursor.fetchone()
				if result[0] == -1:
					cb.append_text(self.usuario)

				cursor.execute("UPDATE usuario SET status = %d WHERE nome = '%s';" % (self.status, self.usuario))
				cursor.execute("UPDATE usuario SET login = '%s' WHERE nome = '%s';" % (self.login_entry.get_text(), self.usuario))
				cursor.execute("UPDATE usuario SET senha = '%s' WHERE nome = '%s';" % (self.password_entry.get_text(), self.usuario))

				# show a custom dialog
				msg = "As configurações do usuário %s foram atualizadas!" % (self.usuario)
				self.custom_dlg(gtk.MESSAGE_WARNING, "Usuário existente!", msg)

				cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'sucesso ao atualizar usuário %s');" % (self.login_session, self.usuario))

		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Usuário inválido!", "Você deve escolher um usuário para esta operação!")

		database.commit()
		database.close()
		return

	def usuario_del(self, foo=None, cb=None):
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()

		cursor.execute("SELECT status FROM usuario WHERE nome = '%s'" % (self.login_session))
		result = cursor.fetchone()
		if result[0] != 1:
			cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'falha ao descadastrar usuário %s');" % (self.login_session, self.usuario))
			# show a custom dialog
			self.custom_dlg(gtk.MESSAGE_ERROR, "Operação ilegal!", "Você precisa ser administrado para executar esta operação!")
			database.close()
			return

		if self.usuario:
			cursor.execute("SELECT nome FROM usuario WHERE nome = '%s' and status != -1" % (self.usuario))
			result = cursor.fetchone()
			if result[0] == self.login_session:
				self.custom_dlg(gtk.MESSAGE_ERROR, "Operação ilegal!", "Você não tem autorização para excluir-se!")
				database.close()
				return

			if result is not None:
				# register log in database
				cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'sucesso ao descadastrar usuário %s');" % (self.login_session, self.usuario))

				# update data_desregistro in user table
				cursor.execute("UPDATE usuario SET data_desregistro = strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now') WHERE nome = '%s';" % (self.usuario))
				cursor.execute("UPDATE usuario SET status = -1 WHERE nome = '%s';" % (self.usuario))
				database.commit()
				database.close()

				cb.remove_text(cb.get_active())

				# show a custom dialog
				msg = "Usuário %s descadastrado!" % (self.usuario)
				self.custom_dlg(gtk.MESSAGE_INFO, "Operação realizada!", msg)

			else:
				# show a custom dialog
				msg = "Usuário %s inexistente ou desativado!" % (self.usuario)
				self.custom_dlg(gtk.MESSAGE_ERROR, "Erro na operação!", msg)
		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Usuário inválido!", "Você deve escolher um usuário para esta operação!")
		return

	def changed_cb_login(self, cb):
		self.login_temp = cb.get_text()

	def changed_cb_user(self, cb):
		self.usuario = cb.get_text()

		# check if user exists
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()
		
		cursor.execute("SELECT login, senha, status FROM usuario WHERE nome = '%s'" % (self.usuario))
		results = cursor.fetchall()
	
		for entry in results:
			self.login_entry.set_text(entry[0])
			self.password_entry.set_text(entry[1])
			if entry[2] == 1:
				self.userad_checkbox.set_active(True)
			else: 
				self.userad_checkbox.set_active(False)

		database.close()
		return

	def user_is_adm(self, foo=None):
		if self.userad_checkbox.get_active() == True:
			self.status = 1
		else:
			self.status = 0

	def usuario(self, foo=None, bar=None):
		if self.login_session is not None:
			user_window = gtk.Window()
			user_window.set_title("Gerenciar usuários")
			user_window.connect("destroy", lambda w: user_window.destroy())
			user_window.set_size_request(380, 200)
			user_window.set_resizable(True)

			main_vbox = gtk.VBox(False, 0)
			user_window.add(main_vbox)

			# Ajuda
			welcome_vbox = gtk.VBox(True, 0)
			main_vbox.add(welcome_vbox)
			welcome_label = gtk.Label()
			welcome_label.set_label("Cadastrar/Atualizar/Excluir usuários")
			welcome_vbox.pack_start(welcome_label, expand=False, fill=False, padding=5)

			# Informacoes de usuario: Nome
			nome_hbox = gtk.HBox(True, 0)
			main_vbox.add(nome_hbox)
			nome_label = gtk.Label("Nome:")
			nome_hbox.pack_start(nome_label, expand=False, fill=False, padding=5)
			nome_cbentry = gtk.combo_box_entry_new_text()
			nome_hbox.pack_start(nome_cbentry, expand=False, fill=False, padding=0)
			nome_cbentry.child.connect('changed', self.changed_cb_user)

			nome_cbentry.set_active(0)

			# Carregar lista de usuarios cadastrados
			database = sqlite3.connect('database/db.sqlite')
			cursor = database.cursor()
			query = "SELECT nome FROM usuario WHERE status != -1 ORDER BY nome;"
			cursor.execute(query)
			results = cursor.fetchall()

			for entry in results:
				nome_cbentry.append_text(str(entry[0]))

			database.close()

			# Informacoes de usuario: Login
			login_hbox = gtk.HBox(True, 0)
			main_vbox.add(login_hbox)
			login_label = gtk.Label("Login:")
			login_hbox.pack_start(login_label, expand=False, fill=False, padding=5)

			self.login_entry = gtk.Entry()
			login_hbox.pack_start(self.login_entry, expand=False, fill=False, padding=0)

			# Informacoes de usuario: Senha
			password_hbox = gtk.HBox(True, 0)
			main_vbox.add(password_hbox)
			password_label = gtk.Label("Senha:")
			password_hbox.pack_start(password_label, expand=False, fill=False, padding=0)

			self.password_entry = gtk.Entry()
			self.password_entry.set_visibility(False)
			password_hbox.pack_start(self.password_entry, expand=False, fill=False, padding=0)

			# Check if user is admin
			self.status = 1
			user_admin_hbox = gtk.HBox(True, 0)
			main_vbox.add(user_admin_hbox)
			self.userad_checkbox = gtk.CheckButton("Este usuário será um administrador.")
			self.userad_checkbox.connect("toggled", self.user_is_adm)
			user_admin_hbox.pack_start(self.userad_checkbox, expand=False, fill=False, padding=0)

			# Botoes
			button_box = gtk.HButtonBox()
			main_vbox.pack_start(button_box, expand=False, fill=False, padding=0)
			button_box.set_border_width(0)
			button_add = gtk.Button("Cadastrar")
			button_add.connect("clicked", self.usuario_add, nome_cbentry)
			button_box.add(button_add)
			button_del = gtk.Button("Excluir")
			button_del.connect("clicked", self.usuario_del, nome_cbentry)
			button_box.add(button_del)
			button_cancelar = gtk.Button("Sair")
			button_box.add(button_cancelar)
			button_cancelar.connect("clicked", self.destroy, user_window)
			user_window.show_all()

		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Sessão inválida!", "Você deve logar para executar esta operação!")
		self.usuario = None
		return

	def vehicle_has_double(self, foo=None):
		if self.eixo_checkbox.get_active() == True:
			self.vehicle_double = 1
		else:
			self.vehicle_double = 0
		return

	def changed_cbvehicle(self, cb):
		self.placa_vehicle = cb.get_text()

		# check if user exists
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()
		
		cursor.execute("SELECT num_eixos, eixos_duplos FROM veiculo WHERE placa = '%s' and status != -1" % (self.placa_vehicle))
		results = cursor.fetchall()
	
		for entry in results:
			self.spinner.set_text(str(entry[0]))
			if entry[1] == 0:
				self.eixo_checkbox.set_active(False)
			else: 
				self.eixo_checkbox.set_active(True)

		database.close()
		return

	def vehicle_del(self, foo=None, cb=None):
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()

		cursor.execute("SELECT status FROM usuario WHERE nome = '%s'" % (self.login_session))
		result = cursor.fetchone()
		if result[0] != 1:
			cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'falha ao descadastrar veículo %s');" % (self.login_session, self.placa_vehicle))
			# show a custom dialog
			self.custom_dlg(gtk.MESSAGE_ERROR, "Operação ilegal!", "Você precisa ser administrador para executar esta operação!")
			database.close()
			return

		if self.placa_vehicle:
			cursor.execute("SELECT placa FROM veiculo WHERE placa = '%s' and status != -1" % (self.placa_vehicle))
			result = cursor.fetchone()
			if result is not None:
				# register log in database
				cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'sucesso ao descadastrar veículo %s');" % (self.login_session, self.placa_vehicle))

				cb.remove_text(cb.get_active())

				# update data_desregistro in user table
				cursor.execute("UPDATE veiculo SET data_desregistro = strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now') WHERE placa = '%s';" % (self.placa_vehicle))
				cursor.execute("UPDATE veiculo SET status = -1 WHERE placa = '%s';" % (self.placa_vehicle))

				# show a custom dialog
				msg = "Veículo %s descadastrado!" % (self.placa_vehicle)
				self.custom_dlg(gtk.MESSAGE_INFO, "Operação realizada!", msg)

			else:
				# show a custom dialog
				self.custom_dlg(gtk.MESSAGE_ERROR, "Erro na operação!", "Veículo inexistente!")
		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Veículo inválido!", "Você deve escolher um veículo para esta operação!")

		database.commit()
		database.close()
		return

	def vehicle_add(self, foo=None, cb=None):
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()

		cursor.execute("SELECT status FROM usuario WHERE nome = '%s'" % (self.login_session))
		result = cursor.fetchone()
		if result[0] != 1:
			cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'falha ao cadastrar veículo %s');" % (self.login_session, self.placa_vehicle))
			# show a custom dialog
			self.custom_dlg(gtk.MESSAGE_ERROR, "Operação ilegal!", "Você precisa ser administrador para executar esta operação!")
			database.close()
			return

		if self.placa_vehicle:
			cursor.execute("SELECT placa FROM veiculo WHERE placa = '%s'" % (self.placa_vehicle))
			result = cursor.fetchone()

			if result is None:
				# create user
				cursor.execute("INSERT INTO veiculo (placa, num_eixos, eixos_duplos, data_registro, status) VALUES ('%s', %d, %d, strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 0);" % (self.placa_vehicle, self.spinner.get_value_as_int(), self.vehicle_double))
				# register log in database
				cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'sucesso ao cadastrar veículo %s');" % (self.login_session, self.placa_vehicle))

				# show a custom dialog
				msg = "Veículo %s cadastrado!" % (self.placa_vehicle)
				self.custom_dlg(gtk.MESSAGE_INFO, "Operação realizada!", msg)
				cb.append_text(self.placa_vehicle)

			else:
				cursor.execute("SELECT placa FROM veiculo WHERE placa = '%s' and status = 0;" % (self.placa_vehicle))
				result = cursor.fetchone()
				if result:
					# show a custom dialog
					self.custom_dlg(gtk.MESSAGE_ERROR, "Veículo existente!", "Operação cancelada!")
				else:
					if self.spinner.get_value_as_int() is not None:
						cursor.execute("UPDATE veiculo SET status = 0, num_eixos = %d WHERE placa = '%s';" % (self.spinner.get_value_as_int(), self.placa_vehicle))
					else:
						cursor.execute("UPDATE veiculo SET status = 0 WHERE placa = '%s';" % (self.placa_vehicle))
						cb.append_text(self.placa_vehicle)

					# show a custom dialog
					msg = "As configurações do veículo %s foram reativadas!" % (self.placa_vehicle)
					self.custom_dlg(gtk.MESSAGE_INFO, "Veículo existente!", msg)
		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Veículo inválido!", "Você deve escolher um veículo para executar esta operação!")

		database.commit()
		database.close()
		return

	def veiculo(self, foo=None, bar=None):
		if self.login_session is not None:
			self.placa_vehicle = None
			vehicle_window = gtk.Window()
			vehicle_window.set_title("Gerenciar veículos")
			vehicle_window.connect("destroy", lambda w: vehicle_window.destroy())
			vehicle_window.set_size_request(380, 200)
			vehicle_window.set_resizable(True)

			main_vbox = gtk.VBox(False, 0)
			vehicle_window.add(main_vbox)

			# Ajuda
			welcome_vbox = gtk.VBox(True, 0)
			main_vbox.add(welcome_vbox)
			welcome_label = gtk.Label()
			welcome_label.set_label("Cadastrar/Excluir veículos")
			welcome_vbox.pack_start(welcome_label, expand=False, fill=False, padding=5)

			# Placa do veiculo
			placav_hbox = gtk.HBox(True, 0)
			main_vbox.add(placav_hbox)
			placav_label = gtk.Label("Placa do veículo:")
			placav_hbox.pack_start(placav_label, expand=False, fill=False, padding=0)

			self.placav_cbentry = gtk.combo_box_entry_new_text()
			self.placav_cbentry.set_active(0)
			placav_hbox.pack_start(self.placav_cbentry, expand=False, fill=False, padding=0)
			self.placav_cbentry.child.connect('changed', self.changed_cbvehicle)

			# Carregar veiculos cadastrados
			database = sqlite3.connect('database/db.sqlite')
			cursor = database.cursor()
			query = "SELECT placa FROM veiculo WHERE status != -1 ORDER BY placa;"
			cursor.execute(query)
			results = cursor.fetchall()

			for entry in results:
				self.placav_cbentry.append_text(str(entry[0]))

			database.close()

			# Quantidade de eixos
			eixos_hbox = gtk.HBox(True, 0)
			main_vbox.add(eixos_hbox)
			eixos_label = gtk.Label("Número de Eixos:")
			eixos_hbox.pack_start(eixos_label, expand=False, fill=False, padding=0)
			adj = gtk.Adjustment(2.0, 1.0, 4.0, 1.0, 5.0, 0.0)
			self.spinner = gtk.SpinButton(adj, 0, 0)
			self.spinner.set_wrap(True)
			eixos_hbox.pack_start(self.spinner, expand=True, fill=True, padding=0)

			# Eixo duplo
			self.vehicle_double = 0
			eixo_duplo_hbox = gtk.HBox(True, 0)
			main_vbox.add(eixo_duplo_hbox)
			self.eixo_checkbox = gtk.CheckButton("Este veículo possui eixo duplo traseiro.")
			self.eixo_checkbox.connect("toggled", self.vehicle_has_double)
			eixo_duplo_hbox.pack_start(self.eixo_checkbox, expand=False, fill=False, padding=0)

			# Botoes
			button_box = gtk.HButtonBox()
			main_vbox.pack_start(button_box, expand=False, fill=False, padding=0)
			button_box.set_border_width(0)
			button_add = gtk.Button("Cadastrar")
			button_box.add(button_add)
			button_add.connect("clicked", self.vehicle_add, self.placav_cbentry)
			button_del = gtk.Button("Excluir")
			button_box.add(button_del)
			button_del.connect("clicked", self.vehicle_del, self.placav_cbentry)
			button_cancelar = gtk.Button("Sair")
			button_box.add(button_cancelar)
			button_cancelar.connect("clicked", self.destroy, vehicle_window)
			vehicle_window.show_all()
		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Sessão inválida!", "Você deve logar para executar esta operação!")
		return

	def changed_cb_pneu_marca(self, cb):
		self.id_pneu_marca = cb.get_text()

	def changed_cb_pneu_modelo(self, cb):
		self.id_pneu_modelo = cb.get_text()

	def changed_cb_pneu_tamanho(self, cb):
		self.id_pneu_tamanho = cb.get_text()

	def changed_cb_pneu_tipo(self, cb):
		self.id_pneu_tipo = cb.get_text()

	def changed_cb_pneu(self, cb):
		self.id_pneu = cb.get_text()

		# check if user exists
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()
		
		cursor.execute("SELECT placa, marca, modelo, tamanho, tipo, num_recapagens, quilometragem FROM pneu WHERE id_pneu = '%s' and status != -1" % (self.id_pneu))
		results = cursor.fetchone()

		if results is not None:
			if results[0] is not None:
				msg = "Este pneu está sendo utilizado no veículo %s" % (str(results[0]))
				self.eixos_label.set_text(msg)
			else:
				self.eixos_label.set_text("Este pneu não está sendo utilizado")

			self.pneu_marca_cbentry.prepend_text(str(results[1]))
			self.pneu_marca_cbentry.set_active(0)
			self.pneu_marca_cbentry.remove_text(0)

			self.pneu_modelo_cbentry.prepend_text(str(results[2]))
			self.pneu_modelo_cbentry.set_active(0)
			self.pneu_modelo_cbentry.remove_text(0)

			self.pneu_tamanho_cbentry.prepend_text(str(results[3]))
			self.pneu_tamanho_cbentry.set_active(0)
			self.pneu_tamanho_cbentry.remove_text(0)

			self.pneu_tipo_cbentry.prepend_text(str(results[4]))
			self.pneu_tipo_cbentry.set_active(0)
			self.pneu_tipo_cbentry.remove_text(0)

			self.pneu_spinner.set_text(str(results[5]))
			self.km_rodado_entry.set_text(str(results[6]))

		self.database.close()
		return

	def pneu_add(self, foo, cb):
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()

		cursor.execute("SELECT status FROM usuario WHERE nome = '%s'" % (self.login_session))
		result = cursor.fetchone()
		if result[0] != 1:
			cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'falha ao cadastrar pneu %s');" % (self.login_session, self.id_pneu))
			# show a custom dialog
			self.custom_dlg(gtk.MESSAGE_ERROR, "Operação ilegal!", "Você precisa ser administrador para executar esta operação!")
			database.close()
			return

		if len(self.id_pneu) > 0 and len(self.id_pneu_marca) > 0 and len(self.id_pneu_tipo) > 0:
			cursor.execute("SELECT id_pneu FROM pneu WHERE id_pneu = '%s';" % (self.id_pneu))
			result = cursor.fetchone()
			if result is None:
				# create pneu
				cursor.execute("INSERT INTO pneu (id_pneu, marca, modelo, tamanho, tipo, quilometragem, num_recapagens, data_registro, status) VALUES ('%s', '%s', '%s', '%s', '%s', %d, %d, strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 0);" % (self.id_pneu, self.id_pneu_marca, self.id_pneu_modelo, self.id_pneu_tamanho, self.id_pneu_tipo, int(self.km_rodado_entry.get_text()), self.pneu_spinner.get_value_as_int()))
				# register log in database
				cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'sucesso ao cadastrar pneu %s');" % (self.login_session, self.id_pneu))

				cb.append_text(str(self.id_pneu))

				# show a custom dialog
				msg = "Pneu %s cadastrado!" % (self.id_pneu)
				self.custom_dlg(gtk.MESSAGE_INFO, "Operação realizada!", msg)

			else:
				cursor.execute("SELECT status FROM pneu WHERE id_pneu = '%s';" % (self.id_pneu))
				result = cursor.fetchone()
				if result[0] == -1:
					cb.append_text(str(self.id_pneu))

				cursor.execute("UPDATE pneu SET status = 0 WHERE id_pneu = '%s';" % (self.id_pneu))
				cursor.execute("UPDATE pneu SET marca = '%s' WHERE id_pneu = '%s';" % (self.id_pneu_marca, self.id_pneu))
				cursor.execute("UPDATE pneu SET tipo = '%s' WHERE id_pneu = '%s';" % (self.id_pneu_tipo, self.id_pneu))
				cursor.execute("UPDATE pneu SET quilometragem = %d WHERE id_pneu = '%s';" % (int(self.km_rodado_entry.get_text()), self.id_pneu))
				cursor.execute("UPDATE pneu SET num_recapagens = %d WHERE id_pneu = '%s';" % (self.pneu_spinner.get_value_as_int(), self.id_pneu))

				# show a custom dialog
				msg = "As configurações do pneu %s foram atualizadas!" % (self.id_pneu)
				self.custom_dlg(gtk.MESSAGE_WARNING, "Operação concluída!", msg)

				cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'sucesso ao atualizar pneu %s');" % (self.login_session, self.id_pneu))

		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Pneu inválido!", "Você deve preencher todos os campos para executar esta operação!")

		database.commit()
		database.close()
		return


	def pneu_del(self, foo=None, cb=None):
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()

		cursor.execute("SELECT status FROM usuario WHERE nome = '%s'" % (self.login_session))
		result = cursor.fetchone()
		if result[0] != 1:
			cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'falha ao descadastrar pneu %s');" % (self.login_session, self.id_pneu))
			# show a custom dialog
			self.custom_dlg(gtk.MESSAGE_ERROR, "Operação ilegal!", "Você precisa ser administrador para executar esta operação!")
			database.close()
			return

		if len(self.id_pneu) > 0:
			cursor.execute("SELECT id_pneu FROM pneu WHERE id_pneu = '%s' and status != -1" % (self.id_pneu))
			result = cursor.fetchone()
			if result:
				# register log in database
				cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'sucesso ao descadastrar pneu %s');" % (self.login_session, self.id_pneu))

				# update data_desregistro in user table
				cursor.execute("UPDATE pneu SET data_desregistro = strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now') WHERE id_pneu = '%s';" % (self.id_pneu))
				cursor.execute("UPDATE pneu SET status = -1 WHERE id_pneu = '%s';" % (self.id_pneu))
				database.commit()
				database.close()

				# show a custom dialog
				cb.remove_text(cb.get_active())
				msg = "Pneu %s descadastrado!" % (self.id_pneu)
				self.custom_dlg(gtk.MESSAGE_INFO, "Operação realizada!", msg)

				return

			else:
				# show a custom dialog
				self.custom_dlg(gtk.MESSAGE_ERROR, "Erro na operação!", "Pneu inexistente!")
		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Pneu inválido!", "Você deve escolher um pneu para executar esta operação!")

		return

	# abre janela pneus
	def pneus(self, foo=None, bar=None):
		# existe sessão de usuário!?
		if self.login_session is not None:
			pneu_window = gtk.Window()
			pneu_window.set_title("Gerenciar pneus")
			pneu_window.connect("destroy", lambda w: pneu_window.destroy())
			pneu_window.set_size_request(380, 270)
			pneu_window.set_resizable(True)

			main_vbox = gtk.VBox(False, 0)
			pneu_window.add(main_vbox)

			# Ajuda
			welcome_vbox = gtk.VBox(True, 0)
			main_vbox.add(welcome_vbox)
			welcome_label = gtk.Label()
			welcome_label.set_label("Cadastrar/Excluir pneus")
			welcome_vbox.pack_start(welcome_label, expand=False, fill=False, padding=5)

			# id pneu
			self.id_pneu = ''
			pneu_hbox = gtk.HBox(True, 0)
			main_vbox.add(pneu_hbox)
			pneu_label = gtk.Label("ID do pneu:")
			pneu_hbox.pack_start(pneu_label, expand=False, fill=False, padding=0)

			pneu_cbentry = gtk.combo_box_entry_new_text()
			pneu_cbentry.set_active(0)
			pneu_hbox.pack_start(pneu_cbentry, expand=False, fill=False, padding=0)
			pneu_cbentry.child.connect('changed', self.changed_cb_pneu)

			# marca pneu
			pneu_marca_hbox = gtk.HBox(True, 0)
			main_vbox.add(pneu_marca_hbox)
			pneu_marca_label = gtk.Label("Marca do pneu:")
			pneu_marca_hbox.pack_start(pneu_marca_label, expand=False, fill=False, padding=0)

			self.pneu_marca_cbentry = gtk.combo_box_entry_new_text()
			pneu_marca_hbox.pack_start(self.pneu_marca_cbentry, expand=False, fill=False, padding=0)
			self.pneu_marca_cbentry.child.connect('changed', self.changed_cb_pneu_marca)

			# modelo pneu
			pneu_modelo_hbox = gtk.HBox(True, 0)
			main_vbox.add(pneu_modelo_hbox)
			pneu_modelo_label = gtk.Label("Modelo do pneu:")
			pneu_modelo_hbox.pack_start(pneu_modelo_label, expand=False, fill=False, padding=0)

			self.pneu_modelo_cbentry = gtk.combo_box_entry_new_text()
			pneu_modelo_hbox.pack_start(self.pneu_modelo_cbentry, expand=False, fill=False, padding=0)
			self.pneu_modelo_cbentry.child.connect('changed', self.changed_cb_pneu_modelo)

			# tamanho pneu
			pneu_tamanho_hbox = gtk.HBox(True, 0)
			main_vbox.add(pneu_tamanho_hbox)
			pneu_tamanho_label = gtk.Label("Tamanho do pneu:")
			pneu_tamanho_hbox.pack_start(pneu_tamanho_label, expand=False, fill=False, padding=0)

			self.pneu_tamanho_cbentry = gtk.combo_box_entry_new_text()
			pneu_tamanho_hbox.pack_start(self.pneu_tamanho_cbentry, expand=False, fill=False, padding=0)
			self.pneu_tamanho_cbentry.child.connect('changed', self.changed_cb_pneu_tamanho)

			# tipo pneu
			pneu_tipo_hbox = gtk.HBox(True, 0)
			main_vbox.add(pneu_tipo_hbox)
			pneu_tipo_label = gtk.Label("Tipo do pneu:")
			pneu_tipo_hbox.pack_start(pneu_tipo_label, expand=False, fill=False, padding=0)

			self.pneu_tipo_cbentry = gtk.combo_box_entry_new_text()
			pneu_tipo_hbox.pack_start(self.pneu_tipo_cbentry, expand=False, fill=False, padding=0)
			self.pneu_tipo_cbentry.child.connect('changed', self.changed_cb_pneu_tipo)

			# Km rodado
			km_rodado_hbox = gtk.HBox(True, 0)
			main_vbox.add(km_rodado_hbox)
			km_rodado_label = gtk.Label("Quilometragem:")
			km_rodado_hbox.pack_start(km_rodado_label, expand=False, fill=False, padding=0)

			self.km_rodado_entry = gtk.Entry()
			km_rodado_hbox.pack_start(self.km_rodado_entry, expand=False, fill=False, padding=0)

			# Quantidade de recapagens
			recap_pneus_hbox = gtk.HBox(True, 0)
			main_vbox.add(recap_pneus_hbox)
			recap_label = gtk.Label("Número de Recapeamentos:")
			recap_pneus_hbox.pack_start(recap_label, expand=False, fill=False, padding=0)
			adj = gtk.Adjustment(0.0, 0.0, 3.0, 1.0, 0.0, 0.0)
			self.pneu_spinner = gtk.SpinButton(adj, 0, 0)
			self.pneu_spinner.set_wrap(True)
			recap_pneus_hbox.pack_start(self.pneu_spinner, expand=False, fill=False, padding=0)

			# Carregar pneu/marca/tipo cadastrados
			database = sqlite3.connect('database/db.sqlite')
			cursor = database.cursor()
			cursor.execute("SELECT id_pneu FROM pneu WHERE status != -1 ORDER BY id_pneu;")
			results = cursor.fetchall()

			for entry in results:
				pneu_cbentry.append_text(str(entry[0]))

			cursor.execute("SELECT marca FROM pneu WHERE status != -1 GROUP BY marca;")
			results = cursor.fetchall()

			for entry in results:
				self.pneu_marca_cbentry.append_text(str(entry[0]))

			cursor.execute("SELECT modelo FROM pneu WHERE status != -1 ORDER BY id_pneu;")
			results = cursor.fetchall()

			for entry in results:
				self.pneu_modelo_cbentry.append_text(str(entry[0]))

			cursor.execute("SELECT tamanho FROM pneu WHERE status != -1 ORDER BY id_pneu;")
			results = cursor.fetchall()

			for entry in results:
				self.pneu_tamanho_cbentry.append_text(str(entry[0]))

			cursor.execute("SELECT tipo FROM pneu WHERE status != -1 GROUP BY tipo;")
			results = cursor.fetchall()

			for entry in results:
				self.pneu_tipo_cbentry.append_text(str(entry[0]))

			database.close()

			# Quantidade de eixos
			eixos_hbox = gtk.HBox(True, 0)
			main_vbox.add(eixos_hbox)
			self.eixos_label = gtk.Label("")
			eixos_hbox.pack_start(self.eixos_label, expand=False, fill=False, padding=0)

			# Botoes
			button_box = gtk.HButtonBox()
			main_vbox.pack_start(button_box, expand=False, fill=False, padding=0)
			button_box.set_border_width(0)
			button_add = gtk.Button("Cadastrar")
			button_add.connect("clicked", self.pneu_add, pneu_cbentry)
			button_box.add(button_add)
			button_del = gtk.Button("Excluir")
			button_del.connect("clicked", self.pneu_del, pneu_cbentry)
			button_box.add(button_del)
			button_cancelar = gtk.Button("Sair")
			button_box.add(button_cancelar)
			button_cancelar.connect("clicked", self.destroy, pneu_window)
			pneu_window.show_all()
		else:
			# abre janela de erro
			self.custom_dlg(gtk.MESSAGE_ERROR, "Sessão inválida!", "Você deve logar para executar esta operação!")
		return

	# sobre o sistema
	def sobre(self, action, data):
		about = gtk.AboutDialog()
		about.set_program_name("GMO - PNEUS")
		fp = open('VERSION','r')
		about.set_version(fp.readline())
		fp.close()
		about.set_copyright("(c) Gustavo Menezes")
		about.set_comments("Este software é um simples sistema para controle de manutenção de veículos")
		about.set_website("http://gmo-pneus.googlecode.com")
		about.set_logo(gtk.gdk.pixbuf_new_from_file("images/logo.jpg"))
		about.run()
		about.destroy()

	# chamada padrão para fechamento de janelas
	def delete_event(self, widget):
		gtk.main_quit()
		return False

	# carrega menubar
	def get_main_menu(self):
		accel_group = gtk.AccelGroup()

		item_factory = gtk.ItemFactory(gtk.MenuBar, "<main>", accel_group)
		item_factory.create_items(self.menu_items)

		self.main_w.add_accel_group(accel_group)
		self.item_factory = item_factory

		return item_factory.get_widget("<main>")

	# verifica login
	def login_callback(self, widget):
		self.database = sqlite3.connect('database/db.sqlite')
		self.cursor = self.database.cursor()
		self.cursor.execute("SELECT nome FROM usuario WHERE login='%s' and senha='%s' and status != -1" % (self.login_temp, self.password_entry.get_text()))
		self.results = self.cursor.fetchone()

		# confere senha
		if self.results is not None:
			self.login_session = self.login_temp

			# esconde formulário de login
			self.login_hbox.hide()
			self.password_hbox.hide()
			self.button_box.hide()

			# altera statusbar
			aux = self.welcome_label.get_label() + ', ' + str(self.results[0]) + '!'
			self.statusbar.push(0, aux)

			# habilita botões na toolbar
			self.vehicle_button.set_sensitive(True)
			self.tire_button.set_sensitive(True)
			self.manage_button.set_sensitive(True)
			self.report_button.set_sensitive(True)

			# carrega informações do sistema
			self.cursor.execute("SELECT count(login) FROM usuario WHERE status != -1;")
			result = self.cursor.fetchone()
			num_user = str(result[0])

			self.cursor.execute("SELECT count(placa) FROM veiculo WHERE status != -1;")
			result = self.cursor.fetchone()
			num_veiculo = str(result[0])

			self.cursor.execute("SELECT count(placa) FROM veiculo WHERE placa NOT IN (SELECT placa FROM pneu WHERE posicao_eixo LIKE 'estepe%') AND status != -1;")
			result = self.cursor.fetchone()
			num_veiculo_sem_estepe = str(result[0])

			self.cursor.execute("SELECT count(id_pneu) FROM pneu WHERE status != -1;")
			result = self.cursor.fetchone()
			num_pneu = str(result[0])

			self.cursor.execute("SELECT count(id_pneu) FROM pneu WHERE status != -1 AND placa IS NULL;")
			result = self.cursor.fetchone()
			num_pneu_sem_uso = str(result[0])

			self.cursor.execute("SELECT login FROM log WHERE data_registro = (SELECT MAX(data_registro) FROM log WHERE registro LIKE '%sucesso ao logar');")
			result = self.cursor.fetchone()
			if result is None:
				last_login = "Nenhum login detectado"
			else:
				last_login = str(result[0])

			# atualiza log na base de dados
			self.login_session = str(self.results[0])
			self.cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'sucesso ao logar');" % (self.login_session))

			welcome_msg = """Status do Sistema:\n
\tUsuários Cadastrados: %s\n
\tVeículos Cadastrados: %s
\tVeículos Sem Estepe: %s\n
\tPneus Cadastrados: %s
\tPneus Fora de Uso: %s\n
Último Log-In por: %s""" % (num_user, num_veiculo, num_veiculo_sem_estepe, num_pneu, num_pneu_sem_uso, last_login)
			# atualiza welcome label
			self.welcome_label.set_label(welcome_msg)

			# atualiza statusbar
			self.query = "Logado como: %s" % (self.login_session)
			self.statusbar.push(0, self.query)

		else:
			# atualiza statusbar
			self.statusbar.push(0, "Erro ao Logar")

			# atualiza base de dados
			self.cursor.execute("INSERT INTO log (login, data_registro, registro) VALUES ('%s', strftime('%%Y-%%m-%%d %%H:%%M:%%S', 'now'), 'falha ao logar');" % str(self.login_session))

			# exibe mensagem de erro
			self.custom_dlg(gtk.MESSAGE_ERROR, "Erro de Autenticação!", "Usuário ou senha inválido(s)!")
	
		self.database.commit()
		self.database.close()
		return

	# janela de mecânica
	def mecanica(self, foo=None, bar=None):
		# existe sessão ativa de usuário!?
		if self.login_session is not None:
			database = sqlite3.connect('database/db.sqlite')
			cursor = database.cursor()

			cursor.execute("SELECT status FROM usuario WHERE nome = '%s'" % (self.login_session))
			result = cursor.fetchone()
			# usuário tem permissão!?
			if result[0] == 1:
				cursor.execute("SELECT count(placa) FROM veiculo WHERE status != -1;")
				result = cursor.fetchone()
				# existem veículos cadastrados!?
				if result[0] > 0:
					self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
					self.window.set_default_size(430, 500)
					self.window.connect("destroy", lambda w: self.window.destroy())
					self.window.show()
					self.layout = self.makeLayout()
				else:
					self.custom_dlg(gtk.MESSAGE_INFO, "Sistema inacessível!", "Nenhum veículo cadastrado!")
			database.close()
		else:
			self.custom_dlg(gtk.MESSAGE_ERROR, "Operação ilegal!", "Você deve ser administrador para executar esta operação!")
		return

	def open_doc(self, foo=None, bar=None):
		file = "doc/documentacao.pdf"
		if sys.platform == 'linux2':
			os.system("xdg-open %s" % file)
		else:
			os.startfile(file)

		return	

	def imprimir(self, foo=None):
		from reportlab.lib.enums import TA_JUSTIFY
		from reportlab.lib.pagesizes import letter, inch
		from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, Table
		from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
		from reportlab.lib.units import inch
		from reportlab.lib import colors

		nome_relat = "Relatorio-%s.pdf" % (time.strftime("%Y%m%d%H%M", time.localtime()))
		doc = SimpleDocTemplate(nome_relat, pagesize=letter, rightMargin=72, leftMargin=72, topMargin=72, bottomMargin=18)
		Story = []
		logo = "images/logo.jpg"
 
		im = Image(logo, 5*inch, inch/2)
		Story.append(im)
 
		styles=getSampleStyleSheet()
		styles.add(ParagraphStyle(name='Justify', alignment=TA_JUSTIFY))
		Story.append(Spacer(1, 12))
		ptext = '<font size=13><strong>Relatório:</strong></font> <font size=12>%s</font>' % self.relatorio
		Story.append(Paragraph(ptext, styles["Normal"]))
 
		ptext = '<font size=13><strong>Gerado por:</strong></font> <font size=12>%s</font>' % self.login_session
		Story.append(Paragraph(ptext, styles["Normal"]))

		ptext = '<font size=13><strong>Data:</strong></font> <font size=12>%s</font>' % time.strftime("%d/%m/%y - %H:%M:%S", time.localtime())
		Story.append(Paragraph(ptext, styles["Normal"]))
		Story.append(Spacer(1, 12))

		i = 0
		while i < len(self.report_pdf):
			matchObj = re.match('([a-zA-z ]+): (.*) \| ([a-zA-Z ]+):\ (.*) \| ([a-zA-Z ]+): (.*)', self.report_pdf[i])
			if i == 0:
				data=[[matchObj.group(1), matchObj.group(3), matchObj.group(5)]]
				t=Table(data,style=[
					('GRID',(0,0),(-1,-1),0.5,colors.grey),
					('ALIGN',(0,0),(2,0),'CENTER'),
					('BACKGROUND',(0,0),(2,0),colors.black),
					('TEXTCOLOR',(0,0),(2,0),colors.white),
					('LINEABOVE',(0,0),(2,1),0.5,colors.black),
					('LINEBEFORE',(0,0),(2,1),0.5,colors.black),
					('LINEAFTER',(0,0),(2,1),0.5,colors.black)],
					colWidths=[2*inch, 3*inch, 2*inch])

				Story.append(t)

			data=[[matchObj.group(2), matchObj.group(4), matchObj.group(6)]]

			if i % 2 == 0:
				t=Table(data,style=[
					('GRID',(0,0),(-1,-1),0.5,colors.grey),
					('ALIGN',(0,0),(2,0),'CENTER'),
					('BACKGROUND',(0, 0),(2, 1),colors.grey),
					('LINEABOVE',(0,0),(2,1),0.5,colors.black),
					('LINEBEFORE',(0,0),(2,1),0.5,colors.black),
					('LINEAFTER',(0,0),(2,1),0.5,colors.black)],
					colWidths=[2*inch, 3*inch, 2*inch])
			else:
				t=Table(data,style=[
					('GRID',(0,0),(-1,-1),0.5,colors.grey),
					('ALIGN',(0,0),(2,0),'CENTER'),
					('LINEABOVE',(0,0),(2,1),0.5,colors.black),
					('LINEBEFORE',(0,0),(2,1),0.5,colors.black),
					('LINEAFTER',(0,0),(2,1),0.5,colors.black)],
					colWidths=[2*inch, 3*inch, 2*inch])

			Story.append(t)
			i = i + 1

		doc.build(Story)

		# show a custom dialog
		self.custom_dlg(gtk.MESSAGE_INFO, "Operação concluída!", "Relatório gerado com sucesso!")

		time.sleep(0.5)

		if sys.platform == 'linux2':
			os.system("xdg-open %s" % nome_relat)
		else:
			os.startfile(nome_relat)

		return

	# main
	def __init__(self):
		self.login_session = None
		# Main Window
		self.main_w = gtk.Window(gtk.WINDOW_TOPLEVEL)
		self.main_w.connect("destroy", lambda w: gtk.main_quit())
		self.main_w.set_title("Gerenciamento de pneus")
		self.main_w.set_size_request(400, 300)
		self.main_w.set_resizable(True)

		# Vertical Box
		self.main_vbox = gtk.VBox(False, 0)
		self.main_w.add(self.main_vbox)

		# Menubar
		self.menu_items = (
			( "/_Arquivo",			None,		None,		0, "<Branch>" ),
			( "/Arquivo/_Usuários",		"<control>U",	self.usuario,	0, None ),
			( "/Arquivo/sep1",		None,		None,		0, "<Separator>" ),
			( "/Arquivo/_Veículo",		"<control>V",	self.veiculo,	0, None),
			( "/Arquivo/_Pneu",		"<control>P",	self.pneus,	0, None ),
			( "/Arquivo/sep1",		None,		None,		0, "<Separator>" ),
			( "/Arquivo/Mecânica",		None,		self.mecanica,	0, None ),
			( "/Arquivo/Relatório",		None,		self.relatorio,	0, None ),
			( "/Arquivo/sep1",		None,		None,		0, "<Separator>" ),
			( "/Arquivo/Sair",		"<control>Q",	gtk.main_quit,	0, None ),
			( "/A_juda",			None,		None,		0, "<Branch>" ),
			( "/Ajuda/Documentação",	None,		self.open_doc,	0, None),
			( "/Ajuda/sep1",		None,		None,		0, "<Separator>" ),
			( "/Ajuda/_Sobre",		None,		self.sobre,	0, None),
			)

		self.main_menubar = self.get_main_menu()
		self.main_vbox.pack_start(self.main_menubar, expand=False, fill=False, padding=0)

		# ToolBar
		self.main_tb = gtk.Toolbar()
		self.main_vbox.pack_start(self.main_tb, expand=False, fill=False, padding=0)
		self.main_tb.set_orientation(gtk.ORIENTATION_HORIZONTAL)
		self.main_tb.set_style(gtk.TOOLBAR_BOTH)

		# Veiculo
		self.icon_vehicle = gtk.Image()
		self.icon_vehicle.set_from_file("images/veiculo.xpm")
		self.vehicle_button = self.main_tb.append_item(
			"Veículo",
			"Gerenciar Veículos",
			"Private",
			self.icon_vehicle,
			self.veiculo)
		self.vehicle_button.set_sensitive(False)

		# Pneu
		self.icon_tire = gtk.Image()
		self.icon_tire.set_from_file("images/tire.xpm")
		self.tire_button = self.main_tb.append_item(
			"Pneu",
			"Gerenciar Pneus",
			"Private",
			self.icon_tire,
			self.pneus)
		self.tire_button.set_sensitive(False)
		self.main_tb.append_space()

		# Manutencao
		self.icon_manage = gtk.Image()
		self.icon_manage.set_from_file("images/manage.xpm")
		self.manage_button = self.main_tb.append_item(
			"Mecânica",
			"Gerenciar Mecânica",
			"Private",
			self.icon_manage,
			self.mecanica)
		self.manage_button.set_sensitive(False)

		# Relatorio
		self.icon_report = gtk.Image()
		self.icon_report.set_from_file("images/report.xpm")
		self.report_button = self.main_tb.append_item(
			"Relatório",
			"Gerenciar Relatórios",
			"Private",
			self.icon_report,
			self.relatorio)
		self.report_button.set_sensitive(False)
		self.main_tb.append_space()

		# Sair
		self.icon_exit = gtk.Image()
		self.icon_exit.set_from_file("images/exit.xpm")
		self.exit_button = self.main_tb.append_item(
			"Sair",
			"Sair",
			"Private",
			self.icon_exit,
			self.delete_event)
		self.report_button.set_sensitive(False)

		# Bem-vindo
		self.welcome_vbox = gtk.VBox(True, 0)
		self.main_vbox.add(self.welcome_vbox)
		self.welcome_label = gtk.Label()

		self.hour = int(time.strftime("%H", time.localtime()))
		if self.hour >= 5 and self.hour < 12:
			self.welcome_label.set_label("Bom dia")
		elif self.hour >= 12 and self.hour < 18:
			self.welcome_label.set_label("Boa tarde")
		else:
			self.welcome_label.set_label("Boa noite")
		self.welcome_vbox.pack_start(self.welcome_label, expand=False, fill=False, padding=5)

		# Login
		# Informacoes de usuario: Nome
		self.login_hbox = gtk.HBox(True, 0)
		self.main_vbox.add(self.login_hbox)
		self.login_label = gtk.Label("Login:")
		self.login_hbox.pack_start(self.login_label, expand=False, fill=False, padding=5)
		self.login_cbentry = gtk.combo_box_entry_new_text()
		self.login_hbox.pack_start(self.login_cbentry, expand=False, fill=False, padding=0)
		self.login_cbentry.child.connect('changed', self.changed_cb_login)

		self.login_cbentry.set_active(0)

		# Carregar lista de usuarios cadastrados
		database = sqlite3.connect('database/db.sqlite')
		cursor = database.cursor()
		query = "SELECT login FROM usuario WHERE status != -1 ORDER BY login;"
		cursor.execute(query)
		results = cursor.fetchall()

		for entry in results:
			self.login_cbentry.append_text(str(entry[0]))

		database.close()

		# Senha
		self.password_hbox = gtk.HBox(True, 0)
		self.main_vbox.add(self.password_hbox)
		self.password_label = gtk.Label("Senha:")
		self.password_hbox.pack_start(self.password_label, expand=False, fill=False, padding=0)

		self.password_entry = gtk.Entry()
		self.password_entry.set_visibility(False)
		self.password_hbox.pack_start(self.password_entry, expand=False, fill=False, padding=0)

		# Botao Login
		self.button_box = gtk.HButtonBox()
		self.main_vbox.pack_start(self.button_box, expand=False, fill=False, padding=0)
		self.button_box.set_border_width(0)
		self.button_login = gtk.Button("Login")
		self.button_box.add(self.button_login)
		self.button_login.connect("clicked", self.login_callback)

		# Statusbar
		self.statusbar = gtk.Statusbar()
		self.main_vbox.pack_end(self.statusbar, expand=False, fill=True, padding=0)
		self.statusbar.push(0, "Desconectado")

		# Mostrar tudo
		self.main_w.show_all()

def main():
	gtk.main()
	return 0

if __name__ == "__main__":
	DrawGUI()
	main()
